package com.imut.lagain.service.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.imut.lagain.entity.UserRole;
import com.imut.lagain.repository.UserRoleRepository;
import com.imut.lagain.service.IUserRoleService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 用户角色服务实现类
 */
@Service
@RequiredArgsConstructor
@Transactional
public class UserRoleServiceImpl extends ServiceImpl<UserRoleRepository, UserRole> implements IUserRoleService {
    private static final Logger log = LoggerFactory.getLogger(UserRoleServiceImpl.class);

    
    private final PasswordEncoder passwordEncoder;
    
    /**
     * 根据用户ID查询角色
     * @param userId 用户ID
     * @return 用户角色
     */
    @Override
    @Transactional(readOnly = true)
    public UserRole getRoleByUserId(Long userId) {
        if (userId == null) {
            return null;
        }
        return baseMapper.findByUserId(userId);
    }
    
    /**
     * 创建用户角色
     * @param userId 用户ID
     * @param roleType 角色类型
     * @param roleName 角色名称
     * @param adminPassword 管理员密码（仅管理员角色需要）
     * @return 创建的角色
     */
    @Override
    public UserRole createUserRole(Long userId, String roleType, String roleName, String adminPassword) {
        if (userId == null || !StringUtils.hasText(roleType)) {
            throw new IllegalArgumentException("用户ID和角色类型不能为空");
        }
        UserRole existingRole = getRoleByUserId(userId);
        if (existingRole != null) {
            throw new IllegalStateException("用户已存在角色，请先删除现有角色");
        }
        
        UserRole userRole = new UserRole();
        userRole.setUserId(userId);
        userRole.setRoleType(roleType.toUpperCase());
        userRole.setRoleName(StringUtils.hasText(roleName) ? roleName : getRoleNameByType(roleType));
        userRole.setIsActive(true);
        userRole.setIsDeleted(false);
        if ("ADMIN".equalsIgnoreCase(roleType) && StringUtils.hasText(adminPassword)) {
            userRole.setAdminPassword(passwordEncoder.encode(adminPassword));
        }
        
        boolean saved = this.save(userRole);
        if (saved) {
            return userRole;
        } else {
            log.error("Failed to create user role: userId={}, roleType={}", userId, roleType);
            throw new RuntimeException("创建用户角色失败");
        }
    }
    
    /**
     * 更新用户角色
     * @param userId 用户ID
     * @param roleType 角色类型
     * @param roleName 角色名称
     * @return 是否更新成功
     */
    @Override
    public boolean updateUserRole(Long userId, String roleType, String roleName) {
        if (userId == null) {
            return false;
        }
        
        UserRole userRole = getRoleByUserId(userId);
        if (userRole == null) {
            return false;
        }
        
        boolean updated = false;
        if (StringUtils.hasText(roleType) && !roleType.equals(userRole.getRoleType())) {
            userRole.setRoleType(roleType.toUpperCase());
            updated = true;
        }
        
        if (StringUtils.hasText(roleName) && !roleName.equals(userRole.getRoleName())) {
            userRole.setRoleName(roleName);
            updated = true;
        }
        
        if (updated) {
            return this.updateById(userRole);
        }
        
        return true;
    }
    
    /**
     * 检查用户是否为管理员
     * @param userId 用户ID
     * @return 是否为管理员
     */
    @Override
    @Transactional(readOnly = true)
    public boolean isAdmin(Long userId) {
        return hasRole(userId, "ADMIN");
    }
    
    /**
     * 检查用户是否为伴侣
     * @param userId 用户ID
     * @return 是否为伴侣
     */
    @Override
    @Transactional(readOnly = true)
    public boolean isPartner(Long userId) {
        return hasRole(userId, "PARTNER");
    }
    
    /**
     * 验证管理员密码
     * @param userId 用户ID
     * @param password 密码
     * @return 是否验证成功
     */
    @Override
    @Transactional(readOnly = true)
    public boolean validateAdminPassword(Long userId, String password) {
        if (userId == null || !StringUtils.hasText(password)) {
            return false;
        }
        
        UserRole userRole = getRoleByUserId(userId);
        if (userRole == null || !"ADMIN".equals(userRole.getRoleType()) || !userRole.getIsActive()) {
            return false;
        }
        
        String encodedPassword = userRole.getAdminPassword();
        if (!StringUtils.hasText(encodedPassword)) {
            return false;
        }
        
        return passwordEncoder.matches(password, encodedPassword);
    }
    
    /**
     * 更新管理员密码
     * @param userId 用户ID
     * @param oldPassword 旧密码
     * @param newPassword 新密码
     * @return 是否更新成功
     */
    @Override
    public boolean updateAdminPassword(Long userId, String oldPassword, String newPassword) {
        if (!validateAdminPassword(userId, oldPassword)) {
            return false;
        }
        
        return setAdminPassword(userId, newPassword);
    }
    
    /**
     * 设置管理员密码（首次设置或重置）
     * @param userId 用户ID
     * @param password 密码
     * @return 是否设置成功
     */
    @Override
    public boolean setAdminPassword(Long userId, String password) {
        if (userId == null || !StringUtils.hasText(password)) {
            return false;
        }
        
        if (!isAdmin(userId)) {
            return false;
        }
        
        String encodedPassword = passwordEncoder.encode(password);
        int updated = baseMapper.updateAdminPassword(userId, encodedPassword);
        
        if (updated > 0) {
            return true;
        }
        
        return false;
    }
    
    /**
     * 获取所有管理员
     * @return 管理员列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<UserRole> getAllAdmins() {
        return baseMapper.findAllAdmins();
    }
    
    /**
     * 获取所有伴侣
     * @return 伴侣列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<UserRole> getAllPartners() {
        return baseMapper.findAllPartners();
    }
    
    /**
     * 激活/禁用用户角色
     * @param userId 用户ID
     * @param isActive 是否激活
     * @return 是否操作成功
     */
    @Override
    public boolean updateRoleStatus(Long userId, Boolean isActive) {
        if (userId == null || isActive == null) {
            return false;
        }
        
        int updated = baseMapper.updateActiveStatus(userId, isActive);
        if (updated > 0) {
            return true;
        }
        
        return false;
    }
    
    /**
     * 删除用户角色
     * @param userId 用户ID
     * @return 是否删除成功
     */
    @Override
    public boolean deleteUserRole(Long userId) {
        if (userId == null) {
            return false;
        }
        
        int deleted = baseMapper.deleteByUserId(userId);
        if (deleted > 0) {
            return true;
        }
        
        return false;
    }
    
    /**
     * 检查用户是否有指定角色
     * @param userId 用户ID
     * @param roleType 角色类型
     * @return 是否有该角色
     */
    @Override
    @Transactional(readOnly = true)
    public boolean hasRole(Long userId, String roleType) {
        if (userId == null || !StringUtils.hasText(roleType)) {
            return false;
        }
        
        return baseMapper.existsByUserIdAndRoleType(userId, roleType.toUpperCase());
    }
    
    /**
     * 获取用户角色类型
     * @param userId 用户ID
     * @return 角色类型
     */
    @Override
    @Transactional(readOnly = true)
    public String getUserRoleType(Long userId) {
        UserRole userRole = getRoleByUserId(userId);
        return userRole != null ? userRole.getRoleType() : null;
    }
    
    /**
     * 初始化默认管理员角色
     * @param userId 用户ID
     * @param password 管理员密码
     * @return 是否初始化成功
     */
    @Override
    public boolean initializeAdminRole(Long userId, String password) {
        try {
            UserRole adminRole = createUserRole(userId, "ADMIN", "管理员", password);
            return adminRole != null;
        } catch (Exception e) {
            log.error("Failed to initialize admin role for user: {}", userId, e);
            return false;
        }
    }
    
    /**
     * 设置用户角色
     * @param userId 用户ID
     * @param roleType 角色类型
     * @param roleName 角色名称
     * @param adminPassword 管理员密码
     * @return 用户角色
     */
    @Override
    public UserRole setupUserRole(Long userId, String roleType, String roleName, String adminPassword) {
        // 检查是否已存在角色
        UserRole existingRole = getRoleByUserId(userId);
        if (existingRole != null) {
            // 更新现有角色
            existingRole.setRoleType(roleType.toUpperCase());
            existingRole.setRoleName(StringUtils.hasText(roleName) ? roleName : getRoleNameByType(roleType));
            existingRole.setUpdateTime(LocalDateTime.now());
            
            if ("ADMIN".equalsIgnoreCase(roleType) && StringUtils.hasText(adminPassword)) {
                existingRole.setAdminPassword(passwordEncoder.encode(adminPassword));
            }
            
            boolean updated = this.updateById(existingRole);
            return updated ? existingRole : null;
        } else {
            // 创建新角色
            return createUserRole(userId, roleType, roleName, adminPassword);
        }
    }
    
    /**
     * 获取用户角色
     * @param userId 用户ID
     * @return 用户角色
     */
    @Override
    public UserRole getUserRole(Long userId) {
        return getRoleByUserId(userId);
    }
    
    /**
     * 根据角色类型获取默认角色名称
     * @param roleType 角色类型
     * @return 角色名称
     */
    private String getRoleNameByType(String roleType) {
        if ("ADMIN".equalsIgnoreCase(roleType)) {
            return "管理员";
        } else if ("PARTNER".equalsIgnoreCase(roleType)) {
            return "伴侣";
        }
        return "用户";
    }
}

